home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / gnuish / gsed-203 / utils.c < prev   
C/C++ Source or Header  |  1993-12-15  |  6KB  |  328 lines
  1. /*  Functions from hack's utils library.
  2.     Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
  3.  
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2, or (at your option)
  7.     any later version.
  8.  
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  13.  
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17.  
  18. /* These routines were written as part of a library (by hack), but since most
  19.    people don't have the library, here they are.  */
  20.  
  21. #ifdef __STDC__
  22. #define VOID void
  23. #else
  24. #define VOID char
  25. #endif
  26.  
  27. #include <stdio.h>
  28. #if HAVE_STRING_H || defined(STDC_HEADERS)
  29. #include <string.h>
  30. #else
  31. #include <strings.h>
  32. #endif
  33. #if defined(STDC_HEADERS)
  34. #include <stdlib.h>
  35. #else
  36. #ifdef RX_MEMDBUG
  37. #include <sys/types.h>
  38. #include <malloc.h>
  39. #else
  40. VOID *malloc();
  41. VOID *realloc();
  42. #endif /* ndef RX_MEMDBUG  */
  43. #endif
  44.  
  45. VOID *ck_malloc(int size);
  46. char *__fp_name(FILE *fp);
  47. VOID *ck_realloc(VOID *ptr, int size);
  48.  
  49.  
  50. char *myname;
  51.  
  52.  
  53. #ifdef __STDC__
  54. #include <stdarg.h>
  55.  
  56. /* Print an error message and exit */
  57. void
  58. panic(char *str, ...)
  59. {
  60.     va_list iggy;
  61.  
  62.     fprintf(stderr,"%s: ",myname);
  63.     va_start(iggy,str);
  64. #ifdef HAVE_VPRINTF
  65.     vfprintf(stderr,str,iggy);
  66. #else
  67. #ifdef HAVE_DOPRNT
  68.     _doprnt(str,&iggy,stderr);
  69. #endif
  70. #endif
  71.     va_end(iggy);
  72.     putc('\n',stderr);
  73.     exit(4);
  74. }
  75.  
  76. #else
  77. #include <varargs.h>
  78.  
  79. void
  80. panic(str,va_alist)
  81. char *str;
  82. va_dcl
  83. {
  84.     va_list iggy;
  85.  
  86.     fprintf(stderr,"%s: ",myname);
  87.     va_start(iggy);
  88. #ifdef HAVE_VPRINTF
  89.     vfprintf(stderr,str,iggy);
  90. #else
  91. #ifdef HAVE_DOPRNT
  92.     _doprnt(str,&iggy,stderr);
  93. #endif
  94. #endif
  95.     va_end(iggy);
  96.     putc('\n',stderr);
  97.     exit(4);
  98. }
  99.  
  100. #endif
  101.  
  102. /* Store information about files opened with ck_fopen
  103.    so that error messages from ck_fread, etc can print the
  104.    name of the file that had the error */
  105. #define N_FILE 32
  106.  
  107. struct id {
  108.     FILE *fp;
  109.     char *name;
  110. };
  111.  
  112. static struct id __id_s[N_FILE];
  113.  
  114. /* Internal routine to get a filename from __id_s */
  115. char *
  116. __fp_name(fp)
  117. FILE *fp;
  118. {
  119.     int n;
  120.  
  121.     for(n=0;n<N_FILE;n++) {
  122.         if(__id_s[n].fp==fp)
  123.             return __id_s[n].name;
  124.     }
  125.     return "{Unknown file pointer}";
  126. }
  127.  
  128. /* Panic on failing fopen */
  129. FILE *
  130. ck_fopen(name,mode)
  131. char *name;
  132. char *mode;
  133. {
  134.     FILE    *ret;
  135.     int    n;
  136.  
  137.     ret=fopen(name,mode);
  138.     if(ret==(FILE *)0)
  139.         panic("Couldn't open file %s",name);
  140.     for(n=0;n<N_FILE;n++) {
  141.         if(ret==__id_s[n].fp) {
  142.             free((VOID *)__id_s[n].name);
  143.             __id_s[n].name=(char *)ck_malloc(strlen(name)+1);
  144.             strcpy(__id_s[n].name,name);
  145.             break;
  146.         }
  147.     }
  148.     if(n==N_FILE) {
  149.         for(n=0;n<N_FILE;n++)
  150.             if(__id_s[n].fp==(FILE *)0)
  151.                 break;
  152.         if(n==N_FILE)
  153.             panic("Internal error: too many files open");
  154.         __id_s[n].fp=ret;
  155.         __id_s[n].name=(char *)ck_malloc(strlen(name)+1);
  156.         strcpy(__id_s[n].name,name);
  157.     }
  158.     return ret;
  159. }
  160.  
  161. /* Panic on failing fwrite */
  162. void
  163. ck_fwrite(ptr,size,nmemb,stream)
  164. char *ptr;
  165. int size,nmemb;
  166. FILE *stream;
  167. {
  168.     if(fwrite(ptr,size,nmemb,stream)!=nmemb)
  169.         panic("couldn't write %d items to %s",nmemb,__fp_name(stream));
  170. }
  171.  
  172. /* Panic on failing fclose */
  173. void
  174. ck_fclose(stream)
  175. FILE *stream;
  176. {
  177.     if(fclose(stream)==EOF)
  178.         panic("Couldn't close %s",__fp_name(stream));
  179. }
  180.  
  181. /* Panic on failing malloc */
  182. VOID *
  183. ck_malloc(size)
  184. int size;
  185. {
  186.     VOID *ret;
  187.  
  188.     if(!size)
  189.         size++;
  190.     ret=malloc(size);
  191.     if(ret==(VOID *)0)
  192.         panic("Couldn't allocate memory");
  193.     return ret;
  194. }
  195.  
  196. /* Panic on failing malloc */
  197. VOID *
  198. xmalloc(size)
  199. int size;
  200. {
  201.   return ck_malloc (size);
  202. }
  203.  
  204. /* Panic on failing realloc */
  205. VOID *
  206. ck_realloc(ptr,size)
  207. VOID *ptr;
  208. int size;
  209. {
  210.     VOID *ret;
  211.  
  212.     if (!ptr)
  213.       return ck_malloc (size);
  214.     ret=realloc(ptr,size);
  215.     if(ret==(VOID *)0)
  216.         panic("Couldn't re-allocate memory");
  217.     return ret;
  218. }
  219.  
  220. /* Return a malloc()'d copy of a string */
  221. char *
  222. ck_strdup(str)
  223. char *str;
  224. {
  225.     char *ret;
  226.  
  227.     ret=(char *)ck_malloc(strlen(str)+2);
  228.     strcpy(ret,str);
  229.     return ret;
  230. }
  231.  
  232.  
  233. /* Implement a variable sized buffer of 'stuff'.  We don't know what it is,
  234.    nor do we care, as long as it doesn't mind being aligned by malloc. */
  235.  
  236. struct buffer {
  237.     int    allocated;
  238.     int    length;
  239.     char    *b;
  240. };
  241.  
  242. #define MIN_ALLOCATE 50
  243.  
  244. VOID *
  245. init_buffer()
  246. {
  247.     struct buffer *b;
  248.  
  249.     b=(struct buffer *)ck_malloc(sizeof(struct buffer));
  250.     b->allocated=MIN_ALLOCATE;
  251.     b->b=(char *)ck_malloc(MIN_ALLOCATE);
  252.     b->length=0;
  253.     return (VOID *)b;
  254. }
  255.  
  256. void
  257. flush_buffer(bb)
  258. VOID *bb;
  259. {
  260.     struct buffer *b;
  261.  
  262.     b=(struct buffer *)bb;
  263.     free(b->b);
  264.     b->b=0;
  265.     b->allocated=0;
  266.     b->length=0;
  267.     free(b);
  268. }
  269.  
  270. int
  271. size_buffer(b)
  272. VOID *b;
  273. {
  274.     struct buffer *bb;
  275.  
  276.     bb=(struct buffer *)b;
  277.     return bb->length;
  278. }
  279.  
  280. void
  281. add_buffer(bb,p,n)
  282. VOID *bb;
  283. char *p;
  284. int n;
  285. {
  286.     struct buffer *b;
  287.     int x;
  288.     char * cp;
  289.  
  290.     b=(struct buffer *)bb;
  291.     if(b->length+n>b->allocated) {
  292.         b->allocated = (b->length + n) * 2;
  293.         b->b=(char *)ck_realloc(b->b,b->allocated);
  294.     }
  295.     
  296.     x = n;
  297.     cp = b->b + b->length;
  298.     while (x--)
  299.       *cp++ = *p++;
  300.     b->length+=n;
  301. }
  302.  
  303. void
  304. add1_buffer(bb,ch)
  305. VOID *bb;
  306. int ch;
  307. {
  308.     struct buffer *b;
  309.  
  310.     b=(struct buffer *)bb;
  311.     if(b->length+1>b->allocated) {
  312.         b->allocated*=2;
  313.         b->b=(char *)ck_realloc(b->b,b->allocated);
  314.     }
  315.     b->b[b->length]=ch;
  316.     b->length++;
  317. }
  318.  
  319. char *
  320. get_buffer(bb)
  321. VOID *bb;
  322. {
  323.     struct buffer *b;
  324.  
  325.     b=(struct buffer *)bb;
  326.     return b->b;
  327. }
  328.